package com.warm.orm.eq.sys.agent;

import cn.hutool.core.util.ObjUtil;
import cn.hutool.core.util.StrUtil;
import com.easy.query.api.proxy.client.EasyEntityQuery;
import com.easy.query.api.proxy.entity.select.EntityQueryable;
import com.easy.query.core.api.pagination.EasyPageResult;
import com.easy.query.solon.annotation.Db;
import com.warm.core.page.TableDataInfo;
import com.warm.orm.domain.sys.SysDictType;
import com.warm.orm.domain.sys.proxy.SysDictTypeProxy;
import com.warm.orm.utils.DateParaUtils;
import com.warm.orm.utils.PageUtils;
import com.warm.system.api.orm.agent.SysDictTypeAgent;
import org.noear.solon.annotation.Component;

import java.util.List;

/**
 * 字典表 数据层 orm代理类
 *
 * @author warm
 */
@Component
public class SysDictTypeAgentImpl implements SysDictTypeAgent {

    @Db
    private EasyEntityQuery easyEntityQuery;

    /**
     * 校验字典类型称是否唯一
     *
     * @param dictType 字典类型
     * @return 结果
     */
    @Override
    public SysDictType checkDictTypeUnique(String dictType) {
        return this.easyEntityQuery.queryable(SysDictType.class).where(t -> t.dictType().eq(dictType)).firstOrNull();
    }


    /**
     * 通过字典ID删除字典信息
     *
     * @param dictId 字典ID
     * @return 结果
     */
    @Override
    public int deleteDictTypeById(Long dictId) {
        return (int) this.easyEntityQuery.deletable(SysDictType.class).whereById(dictId).executeRows();
    }

    /**
     * 批量删除字典类型信息
     *
     * @param dictIds 需要删除的字典ID
     * @return 结果
     */
    @Override
    public int deleteDictTypeByIds(Long[] dictIds) {
        return (int) this.easyEntityQuery.deletable(SysDictType.class).where(t -> t.dictId().in(dictIds)).executeRows();
    }

    /**
     * 新增字典类型信息
     *
     * @param dictType 字典类型信息
     * @return 结果
     */
    @Override
    public int insertDictType(SysDictType dictType) {
        return (int) this.easyEntityQuery.insertable(dictType).executeRows();
    }

    /**
     * 根据所有字典类型
     *
     * @return 字典类型集合信息
     */
    @Override
    public List<SysDictType> selectDictTypeAll() {
        return this.easyEntityQuery.queryable(SysDictType.class).toList();
    }

    /**
     * 根据字典类型ID查询信息
     *
     * @param dictId 字典类型ID
     * @return 字典类型
     */
    @Override
    public SysDictType selectDictTypeById(Long dictId) {
        return this.easyEntityQuery.queryable(SysDictType.class).whereById(dictId).firstOrNull();
    }

    /**
     * 根据字典类型查询信息
     *
     * @param dictType 字典类型
     * @return 字典类型
     */
    @Override
    public SysDictType selectDictTypeByType(String dictType) {
        return this.easyEntityQuery.queryable(SysDictType.class).where(t -> t.dictType().eq(dictType)).firstOrNull();
    }

    /**
     * 根据条件分页查询字典类型
     *
     * @param dictType 字典类型信息
     * @return 字典类型集合信息
     */
    @Override
    public List<SysDictType> selectDictTypeList(SysDictType dictType) {
        return this.buildQuery(dictType).toList();
    }

    private EntityQueryable<SysDictTypeProxy, SysDictType> buildQuery(SysDictType dictType) {
        return this.easyEntityQuery
                .queryable(SysDictType.class)
                .where(t -> {
                    t.dictName().like(StrUtil.isNotBlank(dictType.getDictName()), dictType.getDictName());
                    t.status().eq(StrUtil.isNotBlank(dictType.getStatus()), dictType.getStatus());
                    t.dictType().like(StrUtil.isNotBlank(dictType.getDictType()), dictType.getDictType());
                    t.createTime().rangeClosed(
                            ObjUtil.isNotNull(dictType.getParams().get("beginTime")),
                            DateParaUtils.getStartDate(dictType),
                            ObjUtil.isNotNull(dictType.getParams().get("endTime")),
                            DateParaUtils.getEndDate(dictType)
                    );
                });
    }

    /**
     * 根据条件分页查询字典类型
     *
     * @param dictType 字典类型信息
     * @return 字典类型集合信息
     */
    @Override
    public TableDataInfo<SysDictType> selectDictTypePage(SysDictType dictType) {
        PageUtils.startPage();
        EasyPageResult<SysDictType> pageResult = this.buildQuery(dictType)
                .toPageResult(PageUtils.getLocalPage().getPageNum(), PageUtils.getLocalPage().getPageSize());
        return new TableDataInfo(pageResult.getData(), (int) pageResult.getTotal());
    }

    /**
     * 修改字典类型信息
     *
     * @param dictType 字典类型信息
     * @return 结果
     */
    @Override
    public int updateDictType(SysDictType dictType) {
        return (int) this.easyEntityQuery.updatable(dictType).executeRows();
    }
}
